home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Moscow ML 1.42 / src / mosmllib / test / bytecmac.sml < prev    next >
Encoding:
Text File  |  1997-08-18  |  12.3 KB  |  373 lines  |  [TEXT/R*ch]
  1. (* test/bytechar.sml -- test cases for Byte and Char, suitable for ASCII
  2.    PS 1994-12-10, 1995-05-11, 1995-11-10 *)
  3.  
  4. (* Mac: changed \^M to \^J in three places *)
  5.  
  6. use "auxil.sml";
  7.  
  8. local 
  9.  
  10. in 
  11. val test1 = checkrange (0,255) (fn i => 
  12.     (Word8.toInt o Byte.charToByte o Byte.byteToChar o Word8.fromInt) i = i);
  13.  
  14. val test2 = checkrange (0,Char.maxOrd) (fn i => 
  15.     (Word8.toInt o Byte.charToByte o Char.chr) i = i);
  16.  
  17. val test3 = checkrange (0,255) 
  18.     (fn i => (Char.ord o Byte.byteToChar o Word8.fromInt) i = i);
  19.  
  20. val test4 = checkrange (0, Char.maxOrd) 
  21.     (fn i => (Char.ord o Char.chr) i = i);
  22.  
  23. val test5 = (Char.chr ~1 seq "WRONG") handle Chr => "OK" | _ => "WRONG";
  24.  
  25. val test6 = (Char.chr (Char.maxOrd+1) seq "WRONG") 
  26.             handle Chr => "OK" | _ => "WRONG";
  27.         
  28. val test7 = check("" = Byte.bytesToString (Word8Vector.fromList []));
  29.  
  30. val test8 = 
  31.     check("ABDC" = 
  32.           (Byte.bytesToString o Word8Vector.fromList o map Word8.fromInt)
  33.            [65, 66, 68, 67]);
  34.  
  35. val test9 = check("" = Byte.unpackString(Word8Array.fromList [], 0, SOME 0));
  36.  
  37. local 
  38.     val arr = Word8Array.tabulate(10, fn i => Word8.fromInt(i+65))
  39. in
  40. val test10a = check("" = Byte.unpackString(arr, 0, SOME 0));
  41. val test10b = check("" = Byte.unpackString(arr, 10, SOME 0) 
  42.                    andalso "" = Byte.unpackString(arr, 10, NONE));
  43. val test10c = check("BCDE" = Byte.unpackString(arr, 1, SOME 4));
  44. val test10d = (Byte.unpackString(arr, ~1, SOME 0) seq "WRONG")
  45.               handle Subscript => "OK" | _ => "WRONG";
  46. val test10e = (Byte.unpackString(arr, 11, SOME 0) seq "WRONG")
  47.               handle Subscript => "OK" | _ => "WRONG";
  48. val test10f = (Byte.unpackString(arr, 0, SOME ~1) seq "WRONG")
  49.               handle Subscript => "OK" | _ => "WRONG";
  50. val test10g = (Byte.unpackString(arr, 0, SOME 11) seq "WRONG")
  51.               handle Subscript => "OK" | _ => "WRONG";
  52. val test10h = (Byte.unpackString(arr, 10, SOME 1) seq "WRONG")
  53.               handle Subscript => "OK" | _ => "WRONG";
  54. val test10i = (Byte.unpackString(arr, ~1, NONE) seq "WRONG")
  55.               handle Subscript => "OK" | _ => "WRONG";
  56. val test10j = (Byte.unpackString(arr, 11, NONE) seq "WRONG")
  57.               handle Subscript => "OK" | _ => "WRONG";
  58. end
  59.  
  60. local 
  61.     val vec = Word8Vector.tabulate(10, fn i => Word8.fromInt(i+65))
  62. in
  63. val test11a = check("" = Byte.unpackStringVec(vec, 0, SOME 0));
  64. val test11b = check("" = Byte.unpackStringVec(vec, 10, SOME 0) 
  65.                    andalso "" = Byte.unpackStringVec(vec, 10, NONE));
  66. val test11c = check("BCDE" = Byte.unpackStringVec(vec, 1, SOME 4));
  67. val test11d = (Byte.unpackStringVec(vec, ~1, SOME 0) seq "WRONG")
  68.               handle Subscript => "OK" | _ => "WRONG";
  69. val test11e = (Byte.unpackStringVec(vec, 11, SOME 0) seq "WRONG")
  70.               handle Subscript => "OK" | _ => "WRONG";
  71. val test11f = (Byte.unpackStringVec(vec, 0, SOME ~1) seq "WRONG")
  72.               handle Subscript => "OK" | _ => "WRONG";
  73. val test11g = (Byte.unpackStringVec(vec, 0, SOME 11) seq "WRONG")
  74.               handle Subscript => "OK" | _ => "WRONG";
  75. val test11h = (Byte.unpackStringVec(vec, 10, SOME 1) seq "WRONG")
  76.               handle Subscript => "OK" | _ => "WRONG";
  77. val test11i = (Byte.unpackStringVec(vec, ~1, NONE) seq "WRONG")
  78.               handle Subscript => "OK" | _ => "WRONG";
  79. val test11j = (Byte.unpackStringVec(vec, 11, NONE) seq "WRONG")
  80.               handle Subscript => "OK" | _ => "WRONG";
  81. end
  82.  
  83. val test18 = check(not (Char.contains "" (Char.chr 65))
  84.                    andalso not (Char.contains "aBCDE" (Char.chr 65))
  85.                    andalso (Char.contains "ABCD" (Char.chr 67))
  86.                    andalso not (Char.contains "" #"\000")
  87.                    andalso not (Char.contains "" #"\255")
  88.                    andalso not (Char.contains "azAZ09" #"\000")
  89.                    andalso not (Char.contains "azAZ09" #"\255"));
  90.  
  91. val test19 = check(Char.notContains "" (Char.chr 65)
  92.                    andalso Char.notContains "aBCDE" (Char.chr 65)
  93.                    andalso not (Char.notContains "ABCD" (Char.chr 67))
  94.                    andalso Char.notContains "" #"\000"
  95.                    andalso Char.notContains "" #"\255"
  96.                    andalso Char.notContains "azAZ09" #"\000"
  97.                    andalso Char.notContains "azAZ09" #"\255");
  98.  
  99. val test20 = check(Char.ord Char.maxChar = Char.maxOrd);
  100.  
  101. local 
  102. fun mycontains s c = 
  103.     let val stop = String.size s
  104.         fun h i = i < stop andalso (c = String.sub(s, i) orelse h(i+1))
  105.     in h 0 end;
  106.  
  107. (* Check that p(c) = (mycontains s c) for all characters: *)
  108. fun equivalent p s = 
  109.     let fun h n =
  110.         n > 255 orelse 
  111.         (p (chr n) = mycontains s (chr n)) andalso h(n+1)
  112.     in h 0 end
  113.  
  114. fun checkset p s = check'(fn _ => equivalent p s);
  115.  
  116. val graphchars = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\
  117.  \[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
  118.  
  119. val ascii = "\^@\^A\^B\^C\^D\^E\^F\^G\^H\t\^J\^K\^L\n\^N\^O\^P\
  120.  \\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_\
  121.  \ !\"#$%&'()*+,-./0123456789:;<=>?@\
  122.  \ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\127" 
  123.  
  124. val lowerascii = "\^@\^A\^B\^C\^D\^E\^F\^G\^H\t\^J\^K\^L\n\^N\^O\^P\
  125.  \\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_\
  126.  \ !\"#$%&'()*+,-./0123456789:;<=>?@\
  127.  \abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\127" 
  128.  
  129. val upperascii = "\^@\^A\^B\^C\^D\^E\^F\^G\^H\t\^J\^K\^L\n\^N\^O\^P\
  130.  \\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_\
  131.  \ !\"#$%&'()*+,-./0123456789:;<=>?@\
  132.  \ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\127" 
  133.  
  134. val allchars = 
  135.     let fun h 0 res = chr 0 :: res
  136.           | h n res = h (n-1) (chr n :: res)
  137.     in h 255 [] end
  138.  
  139. open Char
  140. in
  141.  
  142. val test21 = 
  143.     checkset isLower "abcdefghijklmnopqrstuvwxyz";
  144. val test22 = 
  145.     checkset isUpper "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  146. val test23 = 
  147.     checkset isDigit "0123456789";
  148. val test24 = 
  149.     checkset isAlpha "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  150. val test25 = 
  151.     checkset isHexDigit "0123456789abcdefABCDEF";
  152. val test26 = 
  153.     checkset isAlphaNum 
  154.        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  155. val test27 = 
  156.     checkset isPrint (" " ^ graphchars)
  157. val test28 = 
  158.     checkset isSpace " \009\010\011\012\013";
  159. val test29 = 
  160.     checkset isGraph graphchars
  161. val test30 = 
  162.     checkset isAscii ascii
  163.  
  164. val test31 = 
  165.     check'(fn _ => map toLower (explode ascii) = explode lowerascii)
  166. val test32 = 
  167.     check'(fn _ => map toUpper (explode ascii) = explode upperascii)
  168. val test33 = 
  169.     check'(fn _ => 
  170.            map toUpper (explode graphchars)
  171.            seq map toLower (explode graphchars)
  172.            seq true)
  173.  
  174. val test34a =
  175.     check'(fn _ => 
  176.            map pred (List.drop(allchars, 1)) = List.take(allchars, 255));
  177. val test34b = (pred minChar seq "WRONG")
  178.               handle Chr => "OK" | _ => "WRONG";
  179. val test35a =
  180.     check'(fn _ => 
  181.            map succ (List.take(allchars, 255)) = List.drop(allchars, 1));
  182. val test35b = (succ maxChar seq "WRONG")
  183.               handle Chr => "OK" | _ => "WRONG";
  184. end
  185.  
  186.  
  187. (* Test cases for SML character escape functions. *)
  188.  
  189. val test36 = 
  190.     let fun chk (arg, res) = Char.toString arg = res
  191.     in check'(fn _ => List.all chk 
  192.               [(#"\000", "\\^@"),
  193.                (#"\001", "\\^A"),
  194.                (#"\006", "\\^F"),
  195.                (#"\007", "\\a"),
  196.                (#"\008", "\\b"),
  197.                (#"\009", "\\t"),
  198.                (#"\010", "\\r"),
  199.                (#"\011", "\\v"),
  200.                (#"\012", "\\f"),
  201.                (#"\013", "\\n"),
  202.                (#"\014", "\\^N"),
  203.                (#"\031", "\\^_"),
  204.                (#"\032", " "),
  205.                (#"\126", "~"),
  206.                (#"\\", "\\\\"),
  207.                (#"\"", "\\\""),
  208.                (#"A", "A"),
  209.                (#"\127", "\\127"),
  210.                (#"\128", "\\128"),
  211.                (#"\255", "\\255")])
  212.     end;
  213.  
  214. val test37 = 
  215.     let val chars = List.tabulate(256, chr)
  216.         fun chk c = Char.fromString(Char.toString c) = SOME c
  217.     in check'(fn _ => List.all chk chars) end
  218.  
  219. val test38 =                 
  220.     let fun chkFromString (arg, res) = Char.fromString arg = SOME res
  221.         val argResList = 
  222.             [("A", #"A"),
  223.              ("z", #"z"),
  224.              ("@", #"@"),
  225.              ("~", #"~"),
  226.              ("\\a", #"\007"),
  227.              ("\\b", #"\008"),
  228.              ("\\t", #"\009"),
  229.              ("\\r", #"\010"),
  230.              ("\\v", #"\011"),
  231.              ("\\f", #"\012"),
  232.              ("\\n", #"\013"),
  233.              ("\\\\", #"\\"),
  234.              ("\\\"", #"\""),
  235.              ("\\^@", #"\000"),
  236.              ("\\^A", #"\001"),
  237.              ("\\^Z", #"\026"),
  238.              ("\\^_", #"\031"), 
  239.              ("\\000", #"\000"),
  240.              ("\\097", #"a"),
  241.              ("\\255", #"\255"),
  242.              ("\\   \t\n\n \\A", #"A"),
  243.              ("\\   \t\n\n \\z", #"z"),
  244.              ("\\   \t\n\n \\@", #"@"),
  245.              ("\\   \t\n\n \\~", #"~"),
  246.              ("\\   \t\n\n \\\\n", #"\n"),
  247.              ("\\   \t\n\n \\\\t", #"\t"),
  248.              ("\\   \t\n\n \\\\\\", #"\\"),
  249.              ("\\   \t\n\n \\\\\"", #"\""),
  250.              ("\\   \t\n\n \\\\^@", #"\000"),
  251.              ("\\   \t\n\n \\\\^A", #"\001"),
  252.              ("\\   \t\n\n \\\\^Z", #"\026"),
  253.              ("\\   \t\n\n \\\\^_", #"\031"), 
  254.              ("\\   \t\n\n \\\\000", #"\000"),
  255.              ("\\   \t\n\n \\\\097", #"a"),
  256.              ("\\   \t\n\n \\\\255", #"\255")]
  257.     in 
  258.         check'(fn _ => List.all chkFromString argResList)
  259.     end;
  260.  
  261. val test39 = 
  262.     check'(fn _ => List.all (fn arg => Char.fromString arg = NONE)
  263.            ["\\",
  264.             "\\c",
  265.             "\\F",
  266.             "\\e",
  267.             "\\g",
  268.             "\\N",
  269.             "\\T",
  270.             "\\1",
  271.             "\\11",
  272.             "\\256",
  273.             "\\-65",
  274.             "\\~65",
  275.             "\\?",
  276.             "\\^`",
  277.             "\\^a",
  278.             "\\^z",
  279.             "\\   a",
  280.             "\\   a\\B",
  281.             "\\   \\"]);
  282.  
  283. (* Test cases for C string escape functions *)
  284.  
  285. val test40 = 
  286.     let val chars = List.tabulate(256, chr)
  287.     in check'(fn _ => 
  288.               List.map SOME chars 
  289.               = List.map Char.fromCString (List.map Char.toCString chars))
  290.     end;
  291.  
  292. val test41 = 
  293.     let val argResList = 
  294.             [(#"\010", "\\r"),
  295.              (#"\009", "\\t"),
  296.              (#"\011", "\\v"),
  297.              (#"\008", "\\b"),
  298.              (#"\013", "\\n"),
  299.              (#"\012", "\\f"),
  300.              (#"\007", "\\a"),
  301.              (#"\\", "\\\\"),
  302.              (#"?", "\\?"),
  303.              (#"'", "\\'"),
  304.              (#"\"", "\\\"")]
  305.     in
  306.         check'(fn _ => 
  307.                List.all (fn (arg, res) => Char.toCString arg = res) argResList)
  308.     end;
  309.  
  310. val test42 = 
  311.     let fun checkFromCStringSucc (arg, res) = 
  312.             str (valOf (Char.fromCString arg)) = res
  313.         val argResList = 
  314.             [("\\r", "\010"),
  315.              ("\\t", "\009"),
  316.              ("\\v", "\011"),
  317.              ("\\b", "\008"),
  318.              ("\\n", "\013"),
  319.              ("\\f", "\012"),
  320.              ("\\a", "\007"),
  321.              ("\\\\",  "\\"),
  322.              ("\\?", "?"),
  323.              ("\\'", "'"),
  324.              ("\\\"", "\""),
  325.              ("\\1", "\001"),
  326.              ("\\11", "\009"),
  327.              ("\\111", "\073"),
  328.              ("\\1007", "\064"),
  329.              ("\\100A", "\064"),
  330.              ("\\0",   "\000"),
  331.              ("\\377", "\255"),
  332.              ("\\18", "\001"),
  333.              ("\\178", "\015"),
  334.              ("\\1C", "\001"),
  335.              ("\\17C", "\015"),
  336.              ("\\x0", "\000"),
  337.              ("\\xff", "\255"),
  338.              ("\\xFF", "\255"),
  339.              ("\\x1", "\001"),
  340.              ("\\x11", "\017"),
  341.              ("\\xag", "\010"),
  342.              ("\\xAAg", "\170"),
  343.              ("\\x0000000a", "\010"),
  344.              ("\\x0000000a2", "\162"),
  345.              ("\\x0000000ag", "\010"),
  346.              ("\\x0000000A", "\010"),
  347.              ("\\x0000000A2", "\162"),
  348.              ("\\x0000000Ag", "\010"),
  349.              ("\\x00000000000000000000000000000000000000000000000000000000000000011+",
  350.               "\017")]
  351.     in 
  352.         check'(fn _ => List.all checkFromCStringSucc argResList)
  353.     end;
  354.  
  355. val test43 = 
  356.     let fun checkFromCStringFail arg = Char.fromCString arg = NONE
  357.     in
  358.         check'(fn _ => List.all checkFromCStringFail 
  359.                ["\\",
  360.                 "\\X",
  361.                 "\\=",
  362.                 "\\400",
  363.                 "\\777",
  364.                 "\\8",
  365.                 "\\9",
  366.                 "\\c",
  367.                 "\\d",
  368.                 "\\x",
  369.                 "\\x100",
  370.                 "\\xG"])
  371.     end;
  372. end
  373.